home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / st-core.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  12.7 KB  |  517 lines
  1. /* this hacked up ver by jrd, as we don't do core on an ST (they use RAMs) :-}
  2.    and out executable files are different. */
  3.  
  4. /* Work with core dump and executable files, for GDB.
  5.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  6.  
  7. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  8. WARRANTY.  No author or distributor accepts responsibility to anyone
  9. for the consequences of using it or for whether it serves any
  10. particular purpose or works at all, unless he says so in writing.
  11. Refer to the GDB General Public License for full details.
  12.  
  13. Everyone is granted permission to copy, modify and redistribute GDB,
  14. but only under the conditions described in the GDB General Public
  15. License.  A copy of this license is supposed to have been given to you
  16. along with GDB so you can know your rights and responsibilities.  It
  17. should be in a file named COPYING.  Among other things, the copyright
  18. notice and this notice must be preserved on all copies.
  19.  
  20. In other words, go ahead and share GDB, but don't try to stop
  21. anyone else from sharing it farther.  Help stamp out software hoarding!
  22. */
  23.  
  24. #include "defs.h"
  25. #include "param.h"
  26.  
  27. #include <st-out.h>
  28. #include <types.h>
  29. #include <stdio.h>
  30. #include <signal.h>
  31. #include <param.h>
  32. /* #include <dir.h> */
  33. #include <file.h>
  34. #include <stat.h>
  35.  
  36. /* Hook for `exec_file_command' command to call.  */
  37.  
  38. void (*exec_file_display_hook) ();
  39.    
  40. /* File names of core file and executable file.  */
  41.  
  42. static char *corefile;
  43. static char *execfile;
  44.  
  45. /* Descriptors on which core file and executable file are open.
  46.    Note that the execchan is closed when an inferior is created
  47.    and reopened if the inferior dies or is killed.  */
  48.  
  49. static int corechan;
  50. static int execchan;
  51.  
  52. /* Last modification time of executable file.
  53.    Also used in source.c to compare against mtime of a source file.  */
  54.  
  55. int exec_mtime;
  56.  
  57. /* Virtual addresses of bounds of the two areas of memory in the core file.  */
  58.  
  59. static CORE_ADDR data_start;
  60. static CORE_ADDR data_end;
  61. static CORE_ADDR stack_start;
  62. static CORE_ADDR stack_end;
  63.  
  64. /* Virtual addresses of bounds of two areas of memory in the exec file.
  65.    Note that the data area in the exec file is used only when there is no core file.  */
  66.  
  67. CORE_ADDR text_start;
  68. CORE_ADDR text_end;
  69.  
  70. static CORE_ADDR exec_data_start;
  71. static CORE_ADDR exec_data_end;
  72.  
  73. /* Address in executable file of start of text area data.  */
  74.  
  75. static int text_offset;
  76.  
  77. /* Address in executable file of start of data area data.  */
  78.  
  79. static int exec_data_offset;
  80.  
  81. /* Address in core file of start of data area data.  */
  82.  
  83. static int data_offset;
  84.  
  85. /* Address in core file of start of stack area data.  */
  86.  
  87. static int stack_offset;
  88.   
  89. #ifdef COFF_FORMAT
  90. /* various coff data structures */
  91.  
  92. static FILHDR file_hdr;
  93. static SCNHDR text_hdr;
  94. static SCNHDR data_hdr;
  95.  
  96. #endif /* not COFF_FORMAT */
  97.  
  98. /* a.out header of exec file.  */
  99.  
  100. static struct aexec exec_aouthdr;
  101.  
  102. static void validate_files ();
  103. unsigned int register_addr ();
  104.  
  105. core_file_command (filename, from_tty)
  106.      char *filename;
  107.      int from_tty;
  108. {
  109.   fprintf_filtered(stderr, "Not on an ST you don't\n");
  110. }
  111.  
  112. exec_file_command (filename, from_tty)
  113.      char *filename;
  114.      int from_tty;
  115. {
  116.   int val;
  117.  
  118.   /* Eliminate all traces of old exec file.
  119.      Mark text segment as empty.  */
  120.  
  121.   if (execfile)
  122.     free (execfile);
  123.   execfile = 0;
  124.   data_start = 0;
  125.   data_end -= exec_data_start;
  126.   text_start = 0;
  127.   text_end = 0;
  128.   exec_data_start = 0;
  129.   exec_data_end = 0;
  130.   if (execchan >= 0)
  131.     close (execchan);
  132.   execchan = -1;
  133.  
  134.   /* Now open and digest the file the user requested, if any.  */
  135.  
  136.   if (filename)
  137.     {
  138.       execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
  139.             &execfile);
  140.       if (execchan < 0)
  141.     perror_with_name (filename);
  142.  
  143. #ifdef COFF_FORMAT
  144.       {
  145.     int aout_hdrsize;
  146.     int num_sections;
  147.  
  148.     if (read_file_hdr (execchan, &file_hdr) < 0)
  149.       error ("\"%s\": not in executable format.", execfile);
  150.  
  151.     aout_hdrsize = file_hdr.f_opthdr;
  152.     num_sections = file_hdr.f_nscns;
  153.  
  154.     if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
  155.       error ("\"%s\": can't read optional aouthdr", execfile);
  156.  
  157.     if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections) < 0)
  158.       error ("\"%s\": can't read text section header", execfile);
  159.  
  160.     if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections) < 0)
  161.       error ("\"%s\": can't read data section header", execfile);
  162.  
  163.     text_start = exec_aouthdr.text_start;
  164.     text_end = text_start + exec_aouthdr.tsize;
  165.     text_offset = text_hdr.s_scnptr;
  166.     exec_data_start = exec_aouthdr.data_start;
  167.     exec_data_end = exec_data_start + exec_aouthdr.dsize;
  168.     exec_data_offset = data_hdr.s_scnptr;
  169.     data_start = exec_data_start;
  170.     data_end += exec_data_start;
  171.     exec_mtime = file_hdr.f_timdat;
  172.       }
  173. #else /* not COFF_FORMAT */
  174.       {
  175.     struct stat st_exec;
  176.  
  177. #ifdef gould
  178.     FILHDR exec_coffhdr;
  179.  
  180.         val = myread (execchan, &exec_coffhdr, sizeof exec_coffhdr);
  181.         if (val < 0)
  182.           perror_with_name (filename);
  183. #endif
  184.     val = myread (execchan, &exec_aouthdr, sizeof (struct aexec));
  185.  
  186.     if (val < 0)
  187.       perror_with_name (filename);
  188.  
  189.         text_start = A_TXTOFF (exec_aouthdr);
  190.         exec_data_start = A_DATOFF (exec_aouthdr);
  191. #ifdef gould
  192.         text_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr);
  193.         exec_data_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr)
  194.                 + exec_aouthdr.a_text;
  195. #else
  196.     text_offset = A_TXTOFF (exec_aouthdr);
  197.     exec_data_offset = A_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
  198. #endif
  199.     text_end = text_start + exec_aouthdr.a_text;
  200.         exec_data_end = exec_data_start + exec_aouthdr.a_data;
  201.     data_start = exec_data_start;
  202.     data_end += exec_data_start;
  203.  
  204. /*
  205.     fstat (execchan, &st_exec);
  206.     exec_mtime = st_exec.st_mtime;
  207. */
  208.       }
  209. #endif /* not COFF_FORMAT */
  210.  
  211.       validate_files ();
  212.     }
  213.   else if (from_tty)
  214.    printf_filtered ("No exec file now.\n");
  215.  
  216.   /* Tell display code (if any) about the changed file name.  */
  217.   if (exec_file_display_hook)
  218.     (*exec_file_display_hook) (filename);
  219. }
  220.  
  221. /* Call this to specify the hook for exec_file_command to call back.
  222.    This is called from the x-window display code.  */
  223.  
  224. specify_exec_file_hook (hook)
  225.      void (*hook) ();
  226. {
  227.   exec_file_display_hook = hook;
  228. }
  229.  
  230. /* The exec file must be closed before running an inferior.
  231.    If it is needed again after the inferior dies, it must
  232.    be reopened.  */
  233.  
  234. close_exec_file ()
  235. {
  236.   if (execchan >= 0)
  237.     close (execchan);
  238.   execchan = -1;
  239. }
  240.  
  241. reopen_exec_file ()
  242. {
  243.   if (execchan < 0 && execfile != 0)
  244.     {
  245.       char *filename = concat (execfile, "", "");
  246.       exec_file_command (filename, 0);
  247.       free (filename);
  248.     }
  249. }
  250.  
  251. /* If we have both a core file and an exec file,
  252.    print a warning if they don't go together.
  253.    This should really check that the core file came
  254.    from that exec file, but I don't know how to do it.  */
  255.  
  256. static void
  257. validate_files ()
  258. {
  259. }
  260.  
  261. /* Return the name of the executable file as a string.
  262.    ERR nonzero means get error if there is none specified;
  263.    otherwise return 0 in that case.  */
  264.  
  265. char *
  266. get_exec_file (err)
  267.      int err;
  268. {
  269.   if (err && execfile == 0)
  270.     error ("No executable file specified.\n\
  271. Use the \"exec-file\" and \"symbol-file\" commands.");
  272.   return execfile;
  273. }
  274.  
  275. int
  276. have_core_file_p ()
  277. {
  278.   return(0);
  279. }
  280.  
  281. static void
  282. files_info ()
  283. {
  284.   char *symfile;
  285.   extern char *get_sym_file ();
  286.  
  287.   if (execfile)
  288.    printf_filtered ("Executable file \"%s\".\n", execfile);
  289.   else
  290.    printf_filtered ("No executable file\n");
  291.  
  292.   if (have_inferior_p ())
  293.    printf_filtered ("Using the running image of the program, rather than these files.\n");
  294.  
  295.   symfile = get_sym_file ();
  296.   if (symfile != 0)
  297.    printf_filtered ("Symbols loaded from \"%s\".\n", symfile);
  298.  
  299.   if (! have_inferior_p ())
  300.     {
  301.       if (execfile)
  302.     {
  303.      printf_filtered ("Text segment from 0x%x to 0x%x.\n",
  304.           text_start, text_end);
  305.     }
  306.     }
  307. }
  308.  
  309. /* Read "memory data" from core file and/or executable file */
  310.  
  311. read_memory (memaddr, myaddr, len)
  312.      CORE_ADDR memaddr;
  313.      char *myaddr;
  314.      int len;
  315. {
  316. /* fprintf_filtered(stderr, "read-memory(%X, %X, %d) inf %d\n", memaddr, myaddr, len,
  317.     have_inferior_p()); */
  318.   if (have_inferior_p ())
  319.     read_inferior_memory (memaddr, myaddr, len);
  320.   else
  321.     xfer_core_file (memaddr, myaddr, len, 0);
  322. }
  323.  
  324. /* Write LEN bytes of data starting at address MYADDR
  325.    into debugged program memory at address MEMADDR.
  326.    Returns zero if successful, or an errno value if ptrace failed. */
  327.  
  328. int
  329. write_memory (memaddr, myaddr, len)
  330.      CORE_ADDR memaddr;
  331.      char *myaddr;
  332.      int len;
  333. {
  334.   if (have_inferior_p ())
  335.     return write_inferior_memory (memaddr, myaddr, len);
  336.   else
  337.     error ("Can write memory only when program being debugged is running.");
  338. }
  339.  
  340. xfer_core_file (memaddr, myaddr, len)
  341.      CORE_ADDR memaddr;
  342.      char *myaddr;
  343.      int len;
  344. {
  345.   register int i;
  346.   register int val;
  347.   int xferchan;
  348.   char **xferfile;
  349.   int fileptr;
  350.  
  351. /* this can't possibly do anything on the st */
  352.   bzero (myaddr, len);
  353. #if 0
  354.   while (len > 0)
  355.     {
  356.       xferfile = 0;
  357.       xferchan = 0;
  358.  
  359.       /* Determine which file the next bunch of addresses reside in,
  360.      and where in the file.  Set the file's read/write pointer
  361.      to point at the proper place for the desired address
  362.      and set xferfile and xferchan for the correct file.
  363.      If desired address is nonexistent, leave them zero.
  364.      i is set to the number of bytes that can be handled
  365.      along with the next address.  */
  366.  
  367.       if (memaddr < text_start)
  368.     {
  369.       i = min (len, text_start - memaddr);
  370.     }
  371.       else if (memaddr >= text_end && memaddr < data_start)
  372.     {
  373.       i = min (len, data_start - memaddr);
  374.     }
  375.       else if (memaddr >= (corechan >= 0 ? data_end : exec_data_end)
  376.            && memaddr < stack_start)
  377.     {
  378.       i = min (len, stack_start - memaddr);
  379.     }
  380.       else if (memaddr >= stack_end && stack_end != 0)
  381.     {
  382.       i = min (len, - memaddr);
  383.     }
  384.       /* Note that if there is no core file
  385.      data_start and data_end are equal.  */
  386.       else if (memaddr >= data_start && memaddr < data_end)
  387.     {
  388.       i = min (len, data_end - memaddr);
  389.       fileptr = memaddr - data_start + data_offset;
  390.       xferfile = &corefile;
  391.       xferchan = corechan;
  392.     }
  393.       /* Note that if there is no core file
  394.      stack_start and stack_end are equal.  */
  395.       else if (memaddr >= stack_start && memaddr < stack_end)
  396.     {
  397.       i = min (len, stack_end - memaddr);
  398.       fileptr = memaddr - stack_start + stack_offset;
  399.       xferfile = &corefile;
  400.       xferchan = corechan;
  401.     }
  402.       else if (corechan < 0
  403.            && memaddr >= exec_data_start && memaddr < exec_data_end)
  404.     {
  405.       i = min (len, exec_data_end - memaddr);
  406.       fileptr = memaddr - exec_data_start + exec_data_offset;
  407.       xferfile = &execfile;
  408.       xferchan = execchan;
  409.     }
  410.       else if (memaddr >= text_start && memaddr < text_end)
  411.     {
  412.       i = min (len, text_end - memaddr);
  413.       fileptr = memaddr - text_start + text_offset;
  414.       xferfile = &execfile;
  415.       xferchan = execchan;
  416.     }
  417.  
  418.       /* Now we know which file to use.
  419.      Set up its pointer and transfer the data.  */
  420.       if (xferfile)
  421.     {
  422.       if (*xferfile == 0)
  423.         if (xferfile == &execfile)
  424.           error ("No program file to examine.");
  425.         else
  426.           error ("No core dump file or running program to examine.");
  427.       val = lseek (xferchan, fileptr, 0);
  428.       if (val < 0)
  429.         perror_with_name (*xferfile);
  430.       val = myread (xferchan, myaddr, i);
  431.       if (val < 0)
  432.         perror_with_name (*xferfile);
  433.     }
  434.       /* If this address is for nonexistent memory,
  435.      read zeros if reading, or do nothing if writing.  */
  436.       else
  437.     bzero (myaddr, i);
  438.  
  439.       memaddr += i;
  440.       myaddr += i;
  441.       len -= i;
  442.     }
  443. #endif
  444. }
  445.  
  446. /* My replacement for the read system call.
  447.    Used like `read' but keeps going if `read' returns too soon.  */
  448.  
  449. myread (desc, addr, len)
  450.      int desc;
  451.      char *addr;
  452.      int len;
  453. {
  454.   register int val;
  455.   int orglen = len;
  456.  
  457.   while (len > 0)
  458.     {
  459.       val = read (desc, addr, len);
  460.       if (val < 0)
  461.     return val;
  462.       if (val == 0)
  463.     return orglen - len;
  464.       len -= val;
  465.       addr += val;
  466.     }
  467.   return orglen;
  468. }
  469.  
  470. #ifdef REGISTER_U_ADDR
  471.  
  472. /* Return the address in the core dump or inferior of register REGNO.
  473.    BLOCKEND is the address of the end of the user structure.  */
  474.  
  475. unsigned int
  476. register_addr (regno, blockend)
  477.      int regno;
  478.      int blockend;
  479. {
  480.   int addr;
  481.  
  482.   if (regno < 0 || regno >= NUM_REGS)
  483.     error ("Invalid register number %d.", regno);
  484.  
  485.   REGISTER_U_ADDR (addr, blockend, regno);
  486.  
  487.   return addr;
  488. }
  489.  
  490. #endif /* REGISTER_U_ADDR */
  491.  
  492. void
  493. initialize_st_core ()
  494. {
  495.   corechan = -1;
  496.   execchan = -1;
  497.   corefile = 0;
  498.   execfile = 0;
  499.   exec_file_display_hook = 0;
  500.  
  501.   text_start = 0;
  502.   text_end = 0;
  503.   data_start = 0;
  504.   data_end = 0;
  505.   exec_data_start = 0;
  506.   exec_data_end = 0;
  507.   stack_start = 0;
  508.   stack_end = 0;
  509.  
  510.   add_com ("exec-file", class_files, exec_file_command,
  511.        "Use FILE as program for getting contents of pure memory.\n\
  512. If FILE cannot be found as specified, your execution directory path\n\
  513. is searched for a command of that name.\n\
  514. No arg means have no executable file.");
  515.   add_info ("files", files_info, "Names of files being debugged.");
  516. }
  517.